home *** CD-ROM | disk | FTP | other *** search
/ Over 1,000 Windows 95 Programs / Over 1000 Windows 95 Programs (Microforum) (Disc 1).iso / 0842 / winwhois.c < prev    next >
C/C++ Source or Header  |  1997-04-11  |  27KB  |  826 lines
  1. #define WINDOWS
  2. #include <windows.h>
  3. #include <winsock.h>
  4. #include <sys\types.h>
  5. #include <sys\stat.h>
  6. #include <time.h>
  7. #include <stdio.h>
  8. #include <memory.h>
  9. #include "winwhois.h"
  10. #define NICHOST "rs.internic.net"
  11.  
  12. HINSTANCE hInst;
  13. char szQueryhost[128] = NICHOST;
  14. char szHost [256];
  15. char szServHost[128];
  16. REQUEST FAR *HeadReq = NULL;
  17. HANDLE hHeadReq = NULL;
  18. HWND hDialog;
  19.  
  20. int PASCAL WinMain (HINSTANCE hInstCurrent,
  21.             HINSTANCE hInstPrevious,
  22.             LPSTR lpszCmdLine, int nCmdShow)
  23.  
  24. {
  25.     MSG msg;
  26.     HWND hMainWindow;
  27.  
  28.     if (!hInstPrevious)
  29.     if (!InitApplication (hInstCurrent))
  30.         return FALSE;
  31.  
  32.     if (!InitInstance (hInstCurrent, nCmdShow, &hMainWindow))
  33.     return FALSE;
  34.  
  35.     LoadString (hInstCurrent, IDC_WHOISLISTSERVER,
  36.                 (LPSTR)szServHost, 128);
  37.  
  38.     SendMessage (hMainWindow, WM_COMMAND, IDC_STARTDIALOG, 0);
  39.  
  40.     while (GetMessage (&msg, NULL, NULL, NULL))
  41.     {
  42.     TranslateMessage (&msg);
  43.     DispatchMessage (&msg);
  44.     }
  45.     return (msg.wParam);
  46. }
  47.  
  48. BOOL InitApplication (HINSTANCE hInstCurrent)
  49. {
  50.     WNDCLASS wc;
  51.     WNDCLASS windc;
  52.  
  53.     windc.style = NULL;
  54.     windc.lpfnWndProc = QueryWndProc;
  55.  
  56.     windc.cbClsExtra = 0;
  57.     windc.cbWndExtra = 0;
  58.     windc.hInstance = hInstCurrent;
  59.     windc.hIcon = LoadIcon (hInstCurrent, "qmark");
  60.     windc.hCursor = LoadCursor (NULL, IDC_ARROW);
  61.     windc.hbrBackground = GetStockObject (WHITE_BRUSH);
  62.  
  63.     windc.lpszMenuName = NULL;
  64.     windc.lpszClassName = "PurposelessWindow";
  65.     if (!RegisterClass (&windc))
  66.     {
  67.         MessageBox (NULL, "Cannot start program",
  68.                     "WinWhois", MB_OK|MB_ICONHAND);
  69.         return NULL;
  70.     }
  71.  
  72.     wc.style = NULL;
  73.     wc.lpfnWndProc = MainWndProc;
  74.  
  75.     wc.cbClsExtra = 0;
  76.     wc.cbWndExtra = 0;
  77.     wc.hInstance = hInstCurrent;
  78.     wc.hIcon = LoadIcon (hInstCurrent, "qmark");
  79.     wc.hCursor = LoadCursor (NULL, IDC_ARROW);
  80.     wc.hbrBackground = GetStockObject (WHITE_BRUSH);
  81.  
  82.     wc.lpszMenuName = NULL;
  83.     wc.lpszClassName = "UselessWindow";
  84.  
  85.     return (RegisterClass (&wc));
  86. }
  87.  
  88. BOOL InitInstance (HINSTANCE hInstCurrent, int nCmdShow,
  89.            LPHANDLE lphMainWindow )
  90. {
  91.     HWND hWnd;
  92.  
  93.     hInst = hInstCurrent;
  94.     hWnd = CreateWindow ("UselessWindow",
  95.              "whois for Windows",
  96.              WS_OVERLAPPEDWINDOW,
  97.              CW_USEDEFAULT,
  98.              CW_USEDEFAULT,
  99.              CW_USEDEFAULT,
  100.              CW_USEDEFAULT,
  101.              NULL,
  102.              NULL,
  103.              hInstCurrent,
  104.              NULL);
  105.     if (hWnd == NULL)
  106.     return FALSE;
  107.  
  108.     *lphMainWindow = hWnd;
  109.  
  110.     return TRUE;
  111.  
  112. }
  113.  
  114. LONG FAR PASCAL MainWndProc (HWND hWnd, UINT message, WPARAM wParam,
  115.                 LPARAM lParam)
  116.  
  117. {
  118.     FARPROC lpfnProcDialog;
  119.     WORD suword; WSADATA WSAData;
  120.     switch (message) {
  121.     case WM_COMMAND:
  122.         if (wParam != IDC_STARTDIALOG)
  123.         return (DefWindowProc (hWnd, message, wParam, lParam));
  124.         else
  125.         {
  126.             suword = MAKEWORD (1,1);
  127.             WSAStartup (suword, &WSAData);
  128.             lpfnProcDialog = MakeProcInstance ((FARPROC) MainDialog,
  129.                              hInst);
  130.             DialogBox (hInst,
  131.                    "WinWhoIs",
  132.                    hWnd,
  133.                    lpfnProcDialog);
  134.             FreeProcInstance (lpfnProcDialog);
  135.             PostMessage (hWnd, WM_DESTROY, 0, 0);
  136.             break;
  137.         }
  138.     case WM_DESTROY:
  139.         WSACleanup ();
  140.         PostQuitMessage (0);
  141.         break;
  142.  
  143.     default:
  144.         return (DefWindowProc (hWnd, message, wParam, lParam));
  145.      }
  146.     return NULL;
  147.  
  148. }
  149.  
  150. BOOL FAR PASCAL ChangeHost (HWND hDlg, WORD message, WPARAM wParam, LPARAM lParam)
  151.  
  152. {
  153.     char szHost [128];
  154.     switch (message) {
  155.     case WM_INITDIALOG:
  156.         strcpy (szHost, szQueryhost);
  157.         SendDlgItemMessage (hDlg, IDC_HOSTINPUT, (UINT) WM_SETTEXT,
  158.                    (WPARAM) 0,
  159.                    (LPARAM) ((LPSTR) szHost));
  160.         SendDlgItemMessage (hDlg, IDC_HOSTINPUT, (UINT) EM_SETSEL,            
  161.                    (WPARAM) 0,
  162.                    MAKELPARAM (0, -1));
  163.         SendMessage (GetDlgItem (hDlg, IDC_HOSTINPUT), EM_LIMITTEXT, 128, 0L);
  164.         return TRUE;
  165.  
  166.     case WM_COMMAND:
  167.         switch (wParam)
  168.         {
  169.         case IDC_HOSTINPUT:
  170.             if (HIWORD (lParam) == EN_CHANGE) {
  171.             if (SendDlgItemMessage (hDlg, IDC_HOSTINPUT,
  172.                         EM_LINELENGTH, 0, 0L))
  173.                 EnableWindow (GetDlgItem (hDlg, IDC_CHANGEHOST), TRUE);
  174.             else
  175.                 EnableWindow (GetDlgItem (hDlg, IDC_CHANGEHOST), FALSE);
  176.             return TRUE;
  177.             }
  178.             else return FALSE;
  179.         case IDC_CHANGEHOST:
  180.             if (HIWORD (lParam) == BN_CLICKED) 
  181.             {
  182.                 SendDlgItemMessage (hDlg, IDC_HOSTINPUT, (UINT) WM_GETTEXT,
  183.                         (WPARAM) 128,
  184.                         (LPARAM) ((LPSTR) szHost));
  185.                 SendDlgItemMessage (hDlg, IDC_HOSTINPUT, (UINT) EM_SETSEL,
  186.                         0, MAKELPARAM (0,-1));
  187.                 if (*szHost)
  188.                 {
  189.                     strcpy (szQueryhost, szHost);
  190.                 }
  191.                 else {
  192.                 MessageBox (NULL, "No hostname specified!",
  193.                         "WinWhoIs", MB_OK | MB_ICONHAND);
  194.                 }
  195.                 EndDialog (hDlg, TRUE);
  196.                 return TRUE;
  197.             }
  198.             else
  199.                return FALSE;
  200.         case IDCANCEL:
  201.             EndDialog (hDlg, TRUE);
  202.         }
  203.     }
  204.     return FALSE;
  205. }
  206.  
  207. BOOL FAR PASCAL About (HWND hDlg, WORD message, WPARAM wParam, LPARAM lParam)
  208.  
  209. {
  210.     switch (message) {
  211.     case WM_INITDIALOG:
  212.         return TRUE;
  213.  
  214.     case WM_COMMAND:
  215.         if (wParam == IDOK
  216.         || wParam == IDCANCEL)
  217.         {
  218.         EndDialog (hDlg, TRUE);
  219.         return (TRUE);
  220.         }
  221.         break;
  222.     }
  223.     return FALSE;
  224. }
  225.  
  226.  
  227. BOOL FAR PASCAL MainDialog (HWND hDlg, WORD message, WPARAM wParam,
  228.                 LPARAM lParam)
  229.  
  230. {
  231.     char szResponse [256];
  232.  
  233.     int s, i, cc, iOutPos;
  234.     DWORD addr;
  235.     HANDLE hCName;
  236.     LPSTR lpszCName;
  237.  
  238.  
  239.     switch (message)
  240.     {
  241.     case WM_INITDIALOG:
  242.         {
  243.         hDialog = hDlg;
  244.         SendDlgItemMessage (hDlg, IDC_RESPONSES, EM_LIMITTEXT,0,0);
  245.         SendDlgItemMessage (hDlg, IDC_RESPONSES, EM_FMTLINES, 1, 0L);
  246.         EnableWindow (GetDlgItem (hDlg, IDC_MAKEQUERY), 0);
  247.         return TRUE;
  248.         }
  249.     case WM_CLOSE: {
  250.         EndDialog (hDlg, 0);
  251.         break;
  252.         }
  253.  
  254.     case WM_COMMAND:
  255.         switch (wParam) {
  256.         case IDM_ABOUT:
  257.             {
  258.             FARPROC lpfnAboutDialog;
  259.             lpfnAboutDialog = MakeProcInstance (About, hInst);
  260.             DialogBox (hInst,
  261.                    "AboutBox",
  262.                    hDlg,
  263.                    lpfnAboutDialog);
  264.             FreeProcInstance (lpfnAboutDialog);
  265.             return TRUE;
  266.             }
  267.         case IDM_CHANGEHOST:
  268.         {
  269.             FARPROC lpfnChangeDialog;
  270.             lpfnChangeDialog = MakeProcInstance (ChangeHost, hInst);
  271.             DialogBox (hInst, "GetHostBox", hDlg, lpfnChangeDialog);
  272.             FreeProcInstance (lpfnChangeDialog);
  273.             return TRUE;
  274.         }
  275.         case IDM_CUT:
  276.         case IDM_COPY:
  277.         case IDM_CLEAR:
  278.             /* if the selection is empty, make it all... */
  279.             {
  280.             DWORD dwStartAndEnd;
  281.             WORD wStartChar;
  282.             WORD wEndChar;
  283.  
  284.             dwStartAndEnd = SendDlgItemMessage (hDlg,
  285.             IDC_RESPONSES, EM_GETSEL, 0, 0L);
  286.             wStartChar = LOWORD (dwStartAndEnd);
  287.             wEndChar = HIWORD (dwStartAndEnd);
  288.  
  289.             if (wStartChar == wEndChar)
  290.             {
  291.                 SendDlgItemMessage (hDlg, IDC_RESPONSES,
  292.                         EM_SETSEL, 0,
  293.                         MAKELPARAM (0, -1));
  294.                 dwStartAndEnd = SendDlgItemMessage (hDlg,
  295.                 IDC_RESPONSES, EM_GETSEL, 0, 0L);
  296.                 wStartChar = LOWORD (dwStartAndEnd);
  297.                 wEndChar = HIWORD (dwStartAndEnd);
  298.                 if (wStartChar == wEndChar)
  299.                 break;
  300.             }
  301.  
  302.             if (wParam == IDM_CUT)
  303.             SendDlgItemMessage (hDlg, IDC_RESPONSES,
  304.                         WM_CUT, 0,0);
  305.             else if (wParam == IDM_COPY)
  306.             SendDlgItemMessage (hDlg, IDC_RESPONSES,
  307.                         WM_COPY, 0, 0);
  308.             else
  309.             SendDlgItemMessage (hDlg, IDC_RESPONSES,
  310.                         WM_CLEAR, 0, 0);
  311.             SetFocus (GetDlgItem (hDlg, IDC_NAMEINPUT));
  312.             return TRUE;
  313.             }
  314.         case IDC_HELP:
  315.             {
  316.             MessageBox (NULL, "Enter the name you wish to query in the "
  317.                       "Name to Query field, and press return.  "
  318.                       "For help about whois, query on the name "
  319.                       "\"help\".",
  320.                     "WinWhoIs", MB_ICONINFORMATION | MB_OK);
  321.             SetFocus (GetDlgItem (hDlg, IDC_NAMEINPUT));
  322.             return TRUE;
  323.             }
  324.         case IDC_CLEAR:
  325.             if (HIWORD (lParam) == BN_CLICKED)
  326.             {
  327.                 ClearText (hDlg, IDC_RESPONSES);
  328.                 SetFocus (GetDlgItem (hDlg, IDC_NAMEINPUT));
  329.                 return TRUE;
  330.             }
  331.             else
  332.             return FALSE;
  333.         case IDC_NAMEINPUT:
  334.             if (HIWORD (lParam) == EN_CHANGE) {
  335.             if (SendDlgItemMessage (hDlg, IDC_NAMEINPUT,
  336.                         EM_LINELENGTH, 0, 0L))
  337.                 EnableWindow (GetDlgItem (hDlg, IDC_MAKEQUERY),
  338.                       TRUE);
  339.             else
  340.                 EnableWindow (GetDlgItem (hDlg, IDC_MAKEQUERY),
  341.                       FALSE);
  342.             return TRUE;
  343.             }
  344.             else
  345.             return FALSE;
  346.  
  347.         case IDC_MAKEQUERY:                                                   
  348.             if (HIWORD (lParam) == BN_CLICKED) {
  349.             // call the sockets, etc.
  350.                 SendDlgItemMessage (hDlg, IDC_NAMEINPUT, (UINT) WM_GETTEXT,
  351.                         (WPARAM) 255,
  352.                         (LPARAM) ((LPSTR) szHost));
  353.                 SendDlgItemMessage (hDlg, IDC_NAMEINPUT, (UINT) EM_SETSEL,
  354.                         0, MAKELPARAM (0,-1));
  355.                 if (*szHost)
  356.                 {
  357.                     char szStatus[144];
  358.                     strcpy (szStatus, "Querying server '");
  359.                     strcat (szStatus, szQueryhost);
  360.                     strcat (szStatus, "'.");
  361.                     strcat (szHost, "\r\n");
  362.                     SendDlgItemMessage (hDlg, IDC_STATUS, WM_SETTEXT,
  363.                             0, (LPARAM) (LPCSTR)
  364.                             szStatus);
  365.                     DoWhoisQuery (hDlg, (LPSTR)szHost, (LPSTR)szQueryhost);
  366.                     return TRUE;
  367.                 }
  368.                 else {
  369.                 MessageBox (NULL, "No name to query specified!",
  370.                         "WinWhoIs", MB_OK | MB_ICONHAND);
  371.                 return TRUE;
  372.                 }
  373.             }
  374.             else
  375.                return FALSE;
  376.  
  377.         case IDC_GETLIST:
  378.             {
  379.                     char szStatus[144];
  380.                     WSADATA WSAData;
  381.                     strcpy (szStatus, "Querying server '");
  382.                     strcat (szStatus, szServHost);
  383.                     strcat (szStatus, "'.");
  384.                     strcat (szHost, "\r\n");
  385.                     SendDlgItemMessage (hDlg, IDC_STATUS, WM_SETTEXT,
  386.                             0, (LPARAM) (LPCSTR)
  387.                             szStatus);
  388.                     DoWhoisQuery (hDlg, (LPSTR)"whois-servers\r\n", 
  389.                                         (LPSTR)szServHost);
  390.                     return TRUE;
  391.             }
  392.         
  393.         case IDC_EXIT:
  394.             if (HIWORD (lParam) == BN_CLICKED)
  395.             {
  396.                 while (hHeadReq != NULL)
  397.                 {
  398.                     HWND hWindow;
  399.                     hWindow = HeadReq->hWin;
  400.                     closesocket (HeadReq->s);
  401.                     CleanRequest (hWindow);
  402.                     DestroyWindow (hWindow);
  403.                 }
  404.                 EndDialog (hDlg, 0);
  405.                 return TRUE;
  406.             }
  407.             else
  408.             return FALSE;
  409.         }
  410.         return FALSE;
  411.  
  412.     }
  413.     return FALSE;
  414. }
  415.  
  416.  
  417.  
  418. void CopyText (HWND hDlg, WORD wIDControl)
  419. {
  420.  
  421.     HANDLE hWholeString;
  422.     HANDLE hCutString;
  423.     LPSTR lpszWholeString;
  424.     LPSTR lpszCutString;
  425.     DWORD ccControl;
  426.     WORD wStartChar;
  427.     WORD wEndChar;
  428.     DWORD dwStartAndEnd;
  429.  
  430.     dwStartAndEnd = SendDlgItemMessage (hDlg, wIDControl, EM_GETSEL, 0, 0L);
  431.     wStartChar = LOWORD (dwStartAndEnd);
  432.     wEndChar = HIWORD (dwStartAndEnd);
  433.  
  434.     if (wStartChar == wEndChar)
  435.     {
  436.     SendDlgItemMessage (hDlg, wIDControl, EM_SETSEL, 0,
  437.                 MAKELPARAM (0, -1));
  438.     dwStartAndEnd = SendDlgItemMessage (hDlg, wIDControl,
  439.                         EM_GETSEL, 0, 0L);
  440.     wStartChar = LOWORD (dwStartAndEnd);
  441.     wEndChar = HIWORD (dwStartAndEnd);
  442.     if (wStartChar == wEndChar)
  443.         return;
  444.     }
  445.  
  446.     hWholeString = GlobalAlloc (GHND, ccControl =
  447.                  SendDlgItemMessage (hDlg, wIDControl,
  448.                  WM_GETTEXTLENGTH, 0,0) + 256);
  449.     lpszWholeString = GlobalLock (hWholeString);
  450.  
  451.     SendDlgItemMessage (hDlg, wIDControl, WM_GETTEXT, (WPARAM) ccControl,
  452.                (LPARAM) lpszWholeString);
  453.  
  454.  
  455.     hCutString = GlobalAlloc (GHND, wEndChar - wStartChar + 256);
  456.     lpszCutString = GlobalLock (hCutString);
  457.  
  458.     _fmemcpy (lpszCutString, lpszWholeString + wStartChar * sizeof (char),
  459.         (wEndChar - wStartChar) * sizeof (char));
  460.  
  461.     GlobalUnlock (hCutString);
  462.  
  463.     OpenClipboard (hDlg);
  464.     EmptyClipboard ();
  465.     SetClipboardData (CF_TEXT, hCutString);
  466.     CloseClipboard ();
  467.     GlobalFree (hCutString);
  468.  
  469.  
  470.     GlobalUnlock (hWholeString);
  471.     GlobalFree (hWholeString);
  472.  
  473. }
  474.  
  475. void ClearText (HWND hDlg, WORD wIDControl)
  476. {
  477.     DWORD dwStartAndEnd;
  478.     WORD wStartChar;
  479.     WORD wEndChar;
  480.  
  481.     dwStartAndEnd = SendDlgItemMessage (hDlg, wIDControl, EM_GETSEL, 0, 0L);
  482.     wStartChar = LOWORD (dwStartAndEnd);
  483.     wEndChar = HIWORD (dwStartAndEnd);
  484.  
  485.     if (wStartChar == wEndChar)
  486.     SendDlgItemMessage (hDlg, wIDControl, EM_SETSEL, 0,
  487.                 MAKELPARAM (0, -1));
  488.  
  489.     SendDlgItemMessage (hDlg, wIDControl, EM_REPLACESEL, 0,
  490.             (LPARAM) (LPCSTR) "");
  491.  
  492. }
  493.  
  494.  
  495. void DoWhoisQuery (HWND hDlg, LPSTR lpszName, LPSTR lpszQHost)
  496. {
  497.     int s, i, cc, iOutPos;
  498.     char c;
  499.     struct sockaddr_in sin;
  500.     struct servent FAR *sp;
  501.     DWORD addr;
  502.     HANDLE hszLine, hszOutput ;
  503.     LPSTR lpszLine, lpszOutput;
  504.     HANDLE hCName;
  505.     LPSTR lpszCName;
  506.     HANDLE hService;
  507.     HANDLE hWind;
  508.     REQUEST FAR *thisreq;
  509.     
  510.     hWind = CreateWindow ("PurposelessWindow",
  511.          "Whois/Win query",
  512.          WS_OVERLAPPEDWINDOW,
  513.          CW_USEDEFAULT,
  514.          CW_USEDEFAULT,
  515.          CW_USEDEFAULT,
  516.          CW_USEDEFAULT,
  517.          hDlg,
  518.          NULL,
  519.          hInst,
  520.          NULL);
  521.     if (hWind == NULL)
  522.     {    
  523.         MessageBox (NULL, "Could not start query",
  524.                        "WinWhois", MB_OK|MB_ICONHAND);
  525.         return;
  526.     }
  527.  
  528.     thisreq = HeadReq;
  529.     if (thisreq != NULL)
  530.     {
  531.         while (thisreq->NextReq != NULL)
  532.         {
  533.             thisreq = thisreq->NextReq;
  534.         }
  535.         thisreq->hNextReq = GlobalAlloc (GHND, sizeof (REQUEST));
  536.         thisreq->NextReq = (REQUEST FAR*)GlobalLock (thisreq->hNextReq);
  537.         thisreq = thisreq->NextReq;
  538.     }
  539.     else
  540.     {
  541.         hHeadReq = GlobalAlloc (GHND, sizeof (REQUEST));
  542.         HeadReq = (REQUEST FAR*)GlobalLock (hHeadReq);
  543.         thisreq = HeadReq;
  544.     }
  545.     thisreq->hWin = hWind;
  546.     thisreq->hHost = GlobalAlloc (GHND, 256);
  547.     thisreq->lpHost = GlobalLock (thisreq->hHost);
  548.     lstrcpy (thisreq->lpHost, lpszName);
  549.     thisreq->hQuery = GlobalAlloc (GHND, 128);
  550.     thisreq->lpQuery = GlobalLock (thisreq->hQuery);
  551.     lstrcpy (thisreq->lpQuery, lpszQHost);
  552.     thisreq->NextReq = NULL;
  553.     thisreq->hNextReq = NULL;
  554.     PostMessage (hWind, START_QUERY, 0, 0);
  555.     
  556.     return;
  557. }
  558.  
  559. LONG FAR PASCAL QueryWndProc (HWND hWind, UINT message, WPARAM wParam, LPARAM lParam)
  560. {
  561.     int s, i, cc, iOutPos;
  562.     char c;
  563.     struct sockaddr_in sin;
  564.     struct servent FAR *sp;
  565.     DWORD addr;
  566.     HANDLE hszLine, hszOutput, hbuffer, sphandle;
  567.     HANDLE hszCName;
  568.     LPSTR lpszLine, lpszOutput;
  569.     struct hostent FAR *lpbuffer;
  570.     HANDLE hszHost;
  571.     LPSTR lpszHost, lpszCName;
  572.     HANDLE hService;
  573.     REQUEST FAR *thisreq;
  574.         
  575.     switch (message) {
  576.     
  577.         case START_QUERY:
  578.             {
  579.                 thisreq = FindRequest (hWind);
  580.                 thisreq->hbuffer = GlobalAlloc (GHND, MAXGETHOSTSTRUCT);
  581.                 thisreq->lpbuffer = (struct hostent FAR *)GlobalLock (thisreq->hbuffer);
  582.                 WSAAsyncGetHostByName (hWind, IDC_GOTADDR, 
  583.                     thisreq->lpQuery, (LPSTR)thisreq->lpbuffer, MAXGETHOSTSTRUCT);
  584.                 return TRUE;
  585.             }
  586.         case IDC_GOTADDR:
  587.             {
  588.                 unsigned long ii;
  589.                 ii = 1;
  590.                 thisreq = FindRequest (hWind);
  591.  
  592.                 if (WSAGETASYNCERROR (lParam) != 0) {
  593.                 MessageBox (NULL, "Could not resolve host",
  594.                         "WinWhoIs", MB_OK | MB_ICONHAND);
  595.                 GRelease (&thisreq->hbuffer);
  596.                 return FALSE;
  597.                 }
  598.                 _fmemcpy (&addr, thisreq->lpbuffer->h_addr_list[0],
  599.                             thisreq->lpbuffer->h_length);
  600.                 thisreq->s = socket (PF_INET, SOCK_STREAM, 0);
  601.                 if (thisreq->s < 0) {
  602.                     MessageBox (NULL, "Could not create socket for communication",
  603.                         "WinWhoIs", MB_OK | MB_ICONHAND);
  604.                     GRelease (&thisreq->hbuffer);
  605.                     PostMessage (hWind, IDC_RESETDISPLAY, 0, 0);
  606.                 return FALSE;
  607.                 }
  608.                 ioctlsocket (thisreq->s, FIONBIO, (unsigned long FAR *)&ii);
  609.                 thisreq->sock_in.sin_family = PF_INET;
  610.                 thisreq->sock_in.sin_port = 0;
  611.                 thisreq->sock_in.sin_addr.s_addr = INADDR_ANY;
  612.                 if (bind (thisreq->s, (struct sockaddr FAR*) &(thisreq->sock_in),
  613.                      sizeof (thisreq->sock_in)) < 0) {
  614.                     MessageBox (NULL, "Could not bind socket.",
  615.                         "WinWhoIs", MB_OK | MB_ICONHAND);
  616.                     closesocket (thisreq->s);
  617.                     GRelease (&thisreq->hbuffer);
  618.                     PostMessage (hWind, IDC_RESETDISPLAY, 0, 0);
  619.                 return FALSE;
  620.                 }
  621.                 GRelease (&thisreq->hbuffer);
  622.                 thisreq->sphandle = GlobalAlloc (GHND, MAXGETHOSTSTRUCT);
  623.                 thisreq->sp = (struct servent FAR *)GlobalLock (thisreq->sphandle);
  624.                 _fmemcpy ((char FAR *)&(thisreq->sock_in.sin_addr), (char FAR *)&addr, 4);
  625.                 WSAAsyncGetServByName (hWind, IDC_GOTSERVER, "whois", "tcp", 
  626.                     (LPSTR)thisreq->sp, MAXGETHOSTSTRUCT);
  627.                 return TRUE;
  628.             }
  629.         case IDC_GOTSERVER:
  630.             {
  631.                 thisreq = FindRequest (hWind);
  632.                 if (WSAGETASYNCERROR (lParam) != 0) {
  633.                     MessageBox (NULL, "Found no service: whois / tcp",
  634.                         "WinWhoIs", MB_OK | MB_ICONHAND);
  635.                     closesocket (thisreq->s);
  636.                     GRelease (&thisreq->sphandle);
  637.                     PostMessage (hWind, IDC_RESETDISPLAY, 0, 0);
  638.                     return FALSE;
  639.                 }
  640.                 if (!thisreq->sp) {
  641.                     MessageBox (NULL, "Can't lock service: whois / tcp",
  642.                         "WinWhoIs", MB_OK | MB_ICONHAND);
  643.                     closesocket (thisreq->s);
  644.                     GRelease (&thisreq->sphandle);
  645.                     PostMessage (hWind, IDC_RESETDISPLAY, 0, 0);
  646.                     return FALSE;
  647.                 }
  648.                 thisreq->sock_in.sin_port = thisreq->sp -> s_port;
  649.  
  650.                 if (connect (thisreq->s, (struct sockaddr FAR *) &(thisreq->sock_in),
  651.                      sizeof (thisreq->sock_in)) != 0) {
  652.                     int lerror;
  653.                     lerror = WSAGetLastError ();
  654.                     if (lerror == WSAEWOULDBLOCK)
  655.                     {
  656.                         WSAAsyncSelect (thisreq->s, hWind, IDC_GOTCONNECT, FD_CONNECT);
  657.                         GRelease (&thisreq->sphandle);
  658.                         return FALSE;
  659.                     }
  660.                     else
  661.                     {
  662.                         hszLine = GlobalAlloc (GHND, 32);
  663.                         lpszLine = GlobalLock (hszLine);
  664.                         wsprintf (lpszLine,"Could not connect; error #%d", lerror);
  665.                         MessageBox (NULL, lpszLine,
  666.                             "WinWhoIs", MB_OK | MB_ICONHAND);
  667.                         closesocket (thisreq->s);
  668.                         GRelease (&thisreq->sphandle);
  669.                         GRelease (&hszLine);
  670.                         PostMessage (hWind, IDC_RESETDISPLAY, 0, 0);
  671.                         return FALSE;
  672.                     }
  673.                 }
  674.             
  675.                 GRelease (&thisreq->sphandle);
  676.                 /*  Fall Through  */
  677.             }
  678.         case IDC_GOTCONNECT:
  679.             {
  680.                 thisreq = FindRequest (hWind);
  681.                 if (send (thisreq->s, (LPSTR)thisreq->lpHost, 
  682.                         lstrlen ((LPSTR)thisreq->lpHost), 0) == SOCKET_ERROR)    {
  683.                     int lerror;
  684.                     lerror = WSAGetLastError ();
  685.                     if (lerror == WSAEWOULDBLOCK)
  686.                     {
  687.                         WSAAsyncSelect (thisreq->s, hWind, IDC_GOTCONNECT, FD_WRITE);
  688.                         return FALSE;
  689.                     }
  690.                     else
  691.                     {
  692.                         MessageBox (NULL, "Could not send request",
  693.                             "WinWhoIs", MB_OK | MB_ICONHAND);
  694.                         closesocket (thisreq->s);
  695.                         PostMessage (hWind, IDC_RESETDISPLAY, 0, 0);
  696.                         return FALSE;
  697.                     }
  698.                 }
  699.                 WSAAsyncSelect (thisreq->s, hWind, IDC_GOTRESPONSE, FD_READ | FD_CLOSE);
  700.             return TRUE;
  701.             }                       
  702.         case IDC_GOTRESPONSE:
  703.             {
  704.                 hszLine = GlobalAlloc (GHND, 256);
  705.                 lpszLine = GlobalLock (hszLine);
  706.                 hszOutput = GlobalAlloc (GHND, 512);
  707.                 lpszOutput = GlobalLock (hszOutput);
  708.                 s = (int) wParam;
  709.  
  710.                 if ((cc = recv (s, lpszLine, 256, 0)) > 0) {
  711.                     for (i = 0, iOutPos = 0; i < cc; ++i)
  712.                         if (lpszLine [i] == '\n') {
  713.                         lpszOutput [iOutPos++] = '\r';
  714.                         lpszOutput [iOutPos++] = '\n';
  715.                         }
  716.                         else
  717.                         lpszOutput [iOutPos++] = lpszLine [i];
  718.                     
  719.                     lpszOutput [iOutPos] = '\0';
  720.                     SendDlgItemMessage (hDialog, IDC_RESPONSES, EM_REPLACESEL,
  721.                         0, (LPARAM) ((LPCSTR) lpszOutput));
  722.                     GlobalUnlock (hszLine);
  723.                     GlobalFree (hszLine);
  724.                     GlobalUnlock (hszOutput);
  725.                     GlobalFree (hszOutput);
  726.  
  727.                     return FALSE;  /* If there's more, WSASelect() will get it... */
  728.                 }
  729.                 else if (cc != 0)
  730.                 {
  731.                     int ii;
  732.                     if (ii = WSAGetLastError () == WSAEWOULDBLOCK)
  733.                         return FALSE;
  734.                     MessageBox (NULL, "Receiving error occurred.",
  735.                                 "WinWhois", MB_OK | MB_ICONHAND);
  736.                 }
  737.         /*  Now we're done;  clean up  */
  738.  
  739.                 WSAAsyncSelect (s, hWind, 0, 0);
  740.                 if (closesocket (s))
  741.                     MessageBox (NULL, "Socket did not close!", "WinWhois",
  742.                             MB_OK | MB_ICONHAND);
  743.                 GlobalUnlock (hszLine);
  744.                 GlobalFree (hszLine);
  745.                 GlobalUnlock (hszOutput);
  746.                 GlobalFree (hszOutput);
  747.                             SendDlgItemMessage (hDialog, IDC_STATUS, WM_SETTEXT,
  748.                             0, (LPARAM) (LPCSTR)
  749.                             "Waiting for input...");
  750.                     SetFocus (GetDlgItem (hDialog, IDC_NAMEINPUT));
  751.                 /* Fall Through */
  752.             }
  753.             case IDC_RESETDISPLAY:
  754.             {
  755.                 CleanRequest (hWind);
  756.                 DestroyWindow (hWind);
  757.                 return TRUE;
  758.             }
  759.  
  760.        default:
  761.             return (DefWindowProc (hWind, message, wParam, lParam));
  762.       } /*switch*/
  763.     return FALSE;
  764. }
  765.  
  766. REQUEST FAR *FindRequest (HWND hWind)
  767. {
  768.     REQUEST FAR *CurrReq;
  769.     int flag;
  770.     
  771.     flag == TRUE;
  772.     CurrReq = HeadReq;
  773.     while ((CurrReq != NULL) && (flag))
  774.     {
  775.         if (CurrReq->hWin == hWind)
  776.             flag = FALSE;
  777.         else
  778.         {
  779.             CurrReq = CurrReq->NextReq;
  780.         }
  781.     }
  782.     return CurrReq;
  783. }
  784.  
  785. void GRelease (HANDLE FAR *h)
  786. {
  787.     if (*h)
  788.     {
  789.         GlobalUnlock (*h);
  790.         GlobalFree (*h);
  791.         *h=NULL;
  792.     }
  793.     return;
  794. }
  795.  
  796. void CleanRequest (HWND hWind)
  797. {
  798.     REQUEST FAR *thisreq;
  799.     REQUEST FAR *tempreq;
  800.     HANDLE temph;
  801.     
  802.     thisreq = FindRequest (hWind);
  803.     GRelease (&thisreq->hHost);
  804.     GRelease (&thisreq->hQuery);
  805.     GRelease (&thisreq->hbuffer);
  806.     GRelease (&thisreq->sphandle);
  807.     if (thisreq == HeadReq)
  808.     {
  809.         tempreq = thisreq->NextReq;
  810.         temph = thisreq->hNextReq;
  811.         GRelease (&hHeadReq);
  812.         hHeadReq = temph;
  813.         HeadReq = tempreq;
  814.         return;
  815.     }
  816.     tempreq = HeadReq;
  817.     while (tempreq->NextReq != thisreq)
  818.         tempreq = tempreq->NextReq;
  819.     temph = tempreq->hNextReq;
  820.     tempreq->hNextReq = thisreq->hNextReq;
  821.     tempreq->NextReq = thisreq->NextReq;
  822.     GRelease (&temph);
  823.     return;
  824. }
  825.  
  826.